Systems and Methods Providing A Normalized Graphical User Interface For Testing Disparate Devices

ABSTRACT

Systems and methods for a design and runtime environment provide canonical templates for screen components on a device under test. The screen components may include buttons, boxes, icons, menus, scroll areas or text fields.

RELATED APPLICATIONS

This application claims the priority benefit of U.S. ProvisionalApplication Ser. No. 60/685,958 filed May 31, 2005, the contents ofwhich are incorporated herein by reference in their entirety.

This application is related to application Ser. No. ______, filed evendate herewith, entitled “SYSTEMS AND METHODS PROVIDING A DECLARATIVESCREEN MODEL FOR AUTOMATED TESTING”, (Attorney Docket No.: 1642.007US1),application Ser. No. ______, filed even date herewith, entitled “SYSTEMSAND METHODS FOR GRAPHICALLY DEFINING AUTOMATED TEST PROCEDURES”(Attorney Docket No.: 1642.008US1), application Ser. No. ______, filedeven date herewith, entitled “SYSTEMS AND METHODS PROVIDING REUSABLETEST LOGIC” (Attorney Docket No.: 1642.009US1), and application Ser. No.______, filed even date herewith, entitled “SYSTEMS AND METHODS FORMANAGING MULTI-DEVICE TEST SESSIONS” (Attorney Docket No.: 1642.011US1),all of the above of which are hereby incorporated by reference in theirentirety.

LIMITED COPYRIGHT WAIVER

A portion of the disclosure of this patent document contains material towhich the claim of copyright protection is made. The copyright owner hasno objection to the facsimile reproduction by any person of the patentdocument or the patent disclosure, as it appears in the U.S. Patent andTrademark Office file or records, but reserves all other rightswhatsoever. Copyright 2006, TestQuest, Inc.

BACKGROUND

An information-processing system is tested several times over the courseof its life cycle, starting with its initial design and being repeatedevery time the product is modified. Typical information-processingsystems include personal and laptop computers, personal data assistants(PDAs), cellular phones, medical devices washing machines, wristwatches,pagers, and automobile information displays.

Many of these information-processing systems operate with minimalamounts of memory, storage, and processing capability. Because productstoday commonly go through a sizable number of revisions and becausetesting typically becomes more sophisticated over time, this taskbecomes a larger and larger proposition. Additionally, the testing ofsuch information-processing systems is becoming more complex and timeconsuming because an information-processing system may run on severaldifferent platforms with different configurations, and in differentlanguages. Because of this, the testing requirements in today sinformation-processing system development environment continue to grow.

For some organizations, testing is conducted by a test engineer whoidentifies defects by manually running the product through a definedseries of steps and observing the result after each step. Because theseries of steps is intended to both thoroughly exercise productfunctions as well as re-execute scenarios that have identified problemsin the past, the testing process can be rather lengthy and timeconsuming. Add on the multiplicity of tests that must be executed due tosystem size, platform and configuration requirements, and languagerequirements, and one will see that testing has become a time consumingand extremely expensive process.

In today's economy, manufacturers of technology solutions are facing newcompetitive pressures that are forcing them to change the way they bringproducts to market. Being first-to-market with the latest technology ismore important than ever before. But customers require that defects beuncovered and corrected before new products get to market. Additionally,there is pressure to improve profitability by cutting costs anywherepossible.

Product testing has become the focal point where these conflictingdemands collide. Manual testing procedures, long viewed as the only wayto uncover product defects, effectively delay delivery of new productsto the market, and the expense involved puts tremendous pressure onprofitability margins. Additionally, by their nature, manual testingprocedures often fail to uncover all defects.

Automated testing of information-processing system products has begunreplacing manual testing procedures. The benefits of test automationinclude reduced test personnel costs, better test coverage, and quickertime to market. However, an effective automated testing product can becostly and time consuming to implement. The software methods, interfacesand procedures required to thoroughly test an information processingsystem can be nearly as complicated as the information processing systemitself. For example, many information processing systems provide userinterfaces that require navigation through a series of screens, witheach screen potentially requiring input data. In previous systems, eachtest method required the test developer to provide code to navigate tothe desired screen. If the interface changes in subsequent versions ofthe information processing system, the test procedure also typicallymust be modified to reflect the change. Such changes can be costly andtime consuming to implement.

It is common for independent software developers to write softwareprograms that must operate on a diverse set of computing devices. Anexample of this is software developed for mobile phones. Mobile phonesare very heterogeneous with different operating systems, form factors,input mechanisms, screen sizes and color, and GUI styles. This causesapplications to look different and to some extent operate differently oneach mobile platform, even though the basic function of the software ispreserved.

In most software development companies the technicians and engineersresponsible for the testing software applications are not softwareengineers. This is because testing technicians and engineers havehistorically worked in organizations where manual testing methods havebeen the principal method of test. Consequently, the level of softwareengineering skill in a software testing organization is typical low.

In view of the above problems and issues, there is a need in the art forthe present invention.

SUMMARY

Some embodiments of the invention provide a runtime environmentproviding canonical definition for commonly found GUI components andother man machine interfaces (physical buttons, audio input/output,touch screen etc.)

Some embodiments of the invention provide a run-time environmentproviding navigation maps using declarative model defined at design-timeby recording actual manipulation of a physical device through a virtualdevice interface. The navigation maps may be used to automaticallynavigate to application screens eliminating need for test engineer toprovide navigation code.

Some embodiments provide a GUI to represent and define test elements.Defining and recording test steps in graphical form as opposed totextual form in test code.

Some embodiments provide the ability to define an automated testprocedure using test verbs, navigation maps, and other components thatcan run on a variety of different test targets.

Some embodiments provide a concurrent test interface for testingmultiple disparate devices and operating systems for distributedcomputing environments.

Additionally, some embodiments provide the ability to aggregate andmanage one or more remote test devices as a pool of test devices or testsystems.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1A is a block diagram illustrating a system incorporatingembodiments of the invention.

FIG. 1B is a block diagram providing further details of a systemincorporating embodiments of the invention;

FIG. 1C is a block diagram showing the logical relationship of variouscomponents in a system according to embodiments of the invention.

FIG. 2 is a block diagram illustrating object management componentsaccording to embodiments of the invention.

FIG. 3 illustrates an example main screen of a test developmentenvironment according to embodiments of the invention.

FIG. 4 provides a flow illustrating a test design process according toembodiments of the invention.

FIGS. 5A-5D illustrate example navigation map panels of a testdevelopment environment according to embodiments of the invention.

FIG. 6 illustrates an example test case panel of a test developmentenvironment according to embodiments of the invention.

FIG. 7 is a flowchart illustrating methods according to embodiments ofthe invention.

DETAILED DESCRIPTION

In the following detailed description, reference is made to theaccompanying drawings that form a part hereof, and in which is shown byway of illustration, specific embodiments in which the inventive subjectmatter may be practiced. These embodiments are described in sufficientdetail to enable those skilled in the art to practice them, and it is tobe understood that other embodiments may be utilized and thatstructural, logical, and electrical changes may be made withoutdeparting from the scope of the inventive subject matter. Suchembodiments of the inventive subject matter may be referred to,individually and/or collectively, herein by the term “invention” merelyfor convenience and without intending to voluntarily limit the scope ofthis application to any single invention or inventive concept if morethan one is in fact disclosed.

The following description is, therefore, not to be taken in a limitedsense, and the scope of the inventive subject matter is defined by theappended claims of the invention.

In the Figures, the same reference number is used throughout to refer toan identical component which appears in multiple Figures. Signals andconnections may be referred to by the same reference number or label,and the actual meaning will be clear from its use in the context of thedescription.

The functions or algorithms described herein are implemented inhardware, and/or software in embodiments. The software comprisescomputer executable instructions stored on computer readable media suchas memory or other types of storage devices. The term “computer readablemedia” is also used to represent software-transmitted carrier waves.Further, such functions correspond to modules, which are software,hardware, firmware, or any combination thereof. Multiple functions areperformed in one or more modules as desired, and the embodimentsdescribed are merely examples. A digital signal processor, ASIC,microprocessor, or any other type of processor operating on a system,such as a personal computer, server, a router, or any other devicecapable of processing data including network interconnection devicesexecutes the software.

Some embodiments implement functions in two or more specificinterconnected hardware modules or devices with related control and datasignals communicated between and through the modules, or as portions ofan application-specific integrated circuit. Thus, the example processflow is applicable to software, firmware, and hardware implementations.

In the discussion below, the terms “design time” and “run time” may beused to describe aspects of the operation of various embodiments. Ingeneral, the term “design time” refers to activities and/or operationsthat take place during the design of a particular test case or test set.In general, the term “run time” refers to activities and/or operationsthat take place during the execution of a test case or a test set oftest cases.

System Overview

As noted above, it is common for independent software developers towrite software programs that must operate on a diverse set ofheterogeneous computing devices where applications to look different andto some extent operate differently on each mobile platform, even thoughthe basic function of the software is preserved. In these types ofsoftware development environments it is essential for an automated testsystem to facilitate and maximize the reuse of test logic. Without asystematic and automated approach for managing the complexity of testlogic reuse, automated software testing is not economically viable.

Further, as noted above, in most software development companies thetechnicians and engineers responsible for the testing softwareapplications are not software engineers. Given this situation, it isdesirable that a productive and viable tool for automated testing besimple to understand, intuitive in its operation, and hide and manage asmuch complexity as possible.

FIG. 1A is a block diagram illustrating a system 100 incorporatingembodiments of the invention. In some embodiments, system 100 includes atest development environment 102, development repository 120, testmanagement repository 130 and a device under test (DUT) 140.

DUT 140 may be any type of device incorporating processing logic. Suchdevice include but are not limited to personal digital assistants(PDAs), cellular telephones, mobile computing devices, laptop computers,handheld computers, personal computers, server computers mainframecomputers, workstation computers and combinations of the above. DUT 140may include one or more systems under test, including applications thatmay be tested using embodiments of the invention.

Test interface 142 provides an interface between the DUT 140 and thetest development environment 102. The test interface communicatescommands and stimulus from the test development environment 102 to theDUT 140 and communicates the DUT's response to the commands and stimulusback to the test development environment 102. In some embodiments, thetest interface is a minimally invasive software test agent that resideson the DUT. In general, the minimally invasive software test agentprovides stimulus to the device and provides a bitmap comprising ascreen on the device displayed in response to the stimulus. Furtherdetails on such a minimally invasive software test agent may be found inU.S. patent application Ser. No. 10/322,824 entitled “Software TestAgents” which is hereby incorporate by reference herein for allpurposes.

In alternative embodiments, test interface 142 may be a more invasivetest interface that examines the user interface code and data structuresresident on a DUT and uses the current state of the code and data todetermine how to stimulate the DUT and how to interpret responses fromthe DUT.

The DUT may be a physical device that is communicably coupled to thetest system either directly or through a network path. Alternatively,the DUT may be an emulated device in which the characteristics of aphysical device are emulated by software operating on a computing systemthat is communicably coupled to the test system either directly orthough a network path.

Development repository 120 comprises a database of various objects thatmay be created, read, updated and/or deleted using the test developmentenvironment 102. In some embodiments, development repository 120 may bea relational database such as the Microsoft SQL Server database. Inalternative embodiments, repository 120 may be a set of files on a filesystem, an object oriented database, a hierarchical database, or an XMLdatabase. Development repository 120 may contain a variety of objects,include one or more of test sets 121, automated test cases 122, testverbs 123, screen definitions 124, navigation maps 125, platform data126, resource sets 127, virtual device definitions 128, device data 129,global variables 130, data sources 131, platform roles 132 and templates133. Various embodiments will maintain varying combinations of theabove-named components, and no embodiment need necessarily contain allof the above-named components.

Test sets 121 comprise sets of one or more automated test cases 122along with other logic to control the execution or invocation of theautomated test cases 122. In some embodiments of the invention, a testset references test cases only, and does not reference other types ofobjects in the repository 120. Test sets provide a convenient way tomanage groups of test cases that may be applicable for a particular typeof DUT, or groups of DUTs.

Automated test case 122 comprises logic and data that provides adiscrete test unit for a DUT, or group of DUTs. An automated test case122 is a series of one or more test steps and may utilize or referenceone or more test verbs 123, screen definitions 124 and external code150. The steps in an automated test case may be defined using a testcase editor as described below.

Test verbs 123 define logic and actions that may be performed on the DUTor group of DUTs. Further details on test verbs may be found in U.S.patent application Ser. No. 10/323,095 entitled “Method and Apparatusfor Making and Using Test Verbs” and in U.S. patent application Ser. No.10/323,595 entitled “Method and Apparatus for Making and Using WirelessTest Verbs”, each of which are hereby incorporated by reference hereinfor all purposes.

Screen definitions 124 comprises data that may be used to define one ormore screens displayed by software executing on the DUT. For example,the screen definitions may comprise application screens for emailapplications, contact manager applications, calendar applications etc.that execute on a PDA. The data for a screen definition may include abitmap of all or a portion of the screen, and references to screencomponents 133. In some embodiments, a screen may be identified bypresence of a screen component 133 which is a unique identifier for aparticular screen.

Screen components 133 define buttons, menus, dialog boxes, icons, andother user interface elements that may appear on a screen.

A navigation map 125 defines screen transitions describing the deviceinteractions that may be provided to cause the DUT to move from screento screen. A navigation map may include the commands needed to move fromone screen to another, or from one screen to many other screens and viceversa. Further details on navigation maps are described below.

Platform data 126 comprises data that defines properties forabstractions related to platforms, including platform types, platformgroups, and platform definitions. For example a platform type definitiondescribes properties of a platform that are independent of, or genericto, devices that execute the platform system. Examples of variousplatform types include Windows Operating System (OS) platforms, SymbianOS platforms, PocketPC OS platforms, and SmartPhone OS platforms. Aplatform group describes properties of a platform within a platform typethat are generic to groups of operating systems within the type. Forexample, a PocketPC OS platform type may include a group definingproperties for a Pocket PC 2003 operating system and a group definingproperties for a Pocket PC 2003 SE operating system. A platformdefinition describes the properties of a platform within a platformgroup that are generic to one or more devices within the platform group.For example, the PocketPC 2003 operating system group may include aplatform definition that defines the properties of one or more devicesutilizing the PocketPC 2003 operating system. Those of skill in the artwill appreciate that various platforms types, groups, and definitionsnow exist and may be developed in the future, and that such platformsare within the scope of the inventive subject matter. Further, theboundaries and data that define a type or group may vary in variousembodiments. In some embodiments, the data provided as part of aplatform group definition may include one or more of platform name,platform OS, platform GUI (Graphical User Interface) style, platformlanguage, platform screen resolution, platform screen color depth andother device attributes needed to characterize devices. Identificationof the type of virtual device to be used to represent the platform maybe also specified.

Virtual Device 127 comprises data that defines properties of anabstraction of a type of device. For example, a virtual device maycomprise an iPaq type device, or a Treo type device. The virtual devicedata in some embodiments includes data that is common or generic to allof the devices of a particular platform definition. In some embodiments,the data defining a virtual device may include one or more of a deviceskin, keyboard area, hotspots (including possible button states),keyboard properties, touch screen properties, glyph drawing properties,and screen capture parameters such as the screen capture poll rate.

Device 128 comprises data that defines the properties of a particularDUT. In some embodiments, these properties include a device name, adevice OS version, a device GUI style, a device language, a devicescreen resolution, a device screen color depth, and one or more virtualdevices that may be associated with the device 128. In addition, deviceproperties may include connection related properties such as a host nameidentifying a host in a network where the device is connected, aconnection type (e.g. serial, USB, network etc.), a device connectionaddress, and other connection related properties such as message timeoutvalues and command response timeout values. As noted above, the DUT maybe a physical device or an emulated device.

Resource sets 129 comprise data that may be used by the screencomponents described above. For example, in some embodiment text stringsmay be defined in various languages. A resource set for the text stringsfor a particular language may be used by the above-described componentsto provide language independence or to customize the system for aparticular language.

Global variables 130 comprise data that may be used within each logicalunit of a test set or test case.

Data sources 131 comprises data that may be used as a source to provideinput data for a test case or test set. For example, assume that a testcase requires the input of multiple contact names and addresses. A datasource 131 may be used to provide the data for the names and addresses.A data source 131 may be a table or tables in an external RDBMs, or itmay be an external file such as a text file, or a spreadsheet file.

Platform roles 132 represent unique instances of a platform definition.Platform roles may have several functions. In some embodiments, theymake it possible to invoke more than one instance of a platform type atone time. Additionally, they may make it possible to identify whichplatform definitions are the same device and which are different devicesacross one or more test sets, test cases and test verbs. Further, theymay provide an indication of the test role of a particular platformdefinition or device in a test. In some embodiments, a DUT may beassigned roles comprising “primary” and “secondary”. In alternativeembodiments, the user may declare the platform roles. In theseembodiments there may be an arbitrary number of roles, and roles may bearbitrarily labeled providing a user a great deal of flexibility indefining automated tests.

Component Templates 134 comprise standard (or canonical) definitions forvarious user interface elements for a platform type, groups, anddefinition; such as menus, icons, buttons, text fields etc. The standarddefinitions may be used as a basis for defining specialized instances ofthe user interface elements for a particular platform within a platformtype, group, or definition. In addition to setting the properties for ascreen component 133 instance, component templates automate the processof identifying the component instance on the screen. As an example, thecomponent template is dragged onto the screen and the component isautomatically recognized by the template.

Test development environment 102 is a set of one or more softwareapplications that provide a user interface for managing the componentsin repository 120 and for designing and managing automated test cases.In some embodiments, test development environment 102 includes a userinterface 104, a code generator 110, and a debugger 112. In operation,the test development environment 102 reads one or more objects from therepository 120 that become resident objects 114. Resident objects 114may be created, read, updated or deleted using user interface 104.Resident objects may be saved back to the repository 120. In someembodiments, user interface 114 is a graphical use interface that may beused to manipulate objects in repository 120. Further details on a userinterface according to embodiments of the invention are provided belowwith reference to FIGS. 3-6.

In some embodiments, a virtual device interface 106 is part of userinterface 104. Virtual device interface 106 provides a representation ofa DUT (i.e. a skin) that may be used to provide a graphical image of aDUT. The virtual device may have hot spots that correspond to buttons onthe DUT, and may also emulate other aspects of the user interface of aDUT. The virtual device 106 may thus be used to provide stimulus that isrelated to the DUT through the test interface 142. Responses, from theDUT to the stimulus may then be provided through the test interface 142and any screen changes may be shown on the virtual device. The responsemay include an updated screen bitmap that reflects changes on a screenof the DUT. Virtual devices provide a mechanism to develop tests ondevices located at remote locations, and designed to provide aninterface that may be more convenient or easy to use than the actualdevice.

Debugger 112 provides an interface to debug automated test cases 122. Insome embodiments, debugger 112 provides an interface that allowsbreakpoints to be set at certain points in the execution of a test case.In addition, in debugger 112 may provide the ability to single stepthrough one or more steps in a test case, including stepping into orstepping over a sub-component of a test case (e.g. a test verb).Additionally, debugger 112 may provide an interface allowing a user towatch for changes in the local, interface, and global variables used bya test case.

Code generator 110 operates to generate executable code for a test case.In some embodiments, a user utilizes user interface 104 to develop anddebug a test case 122. In some embodiments, the code generatorautomatically and transparently generates and compiles test logic code,for example when the test code is ready to be executed or debugged. Thecode generator reads the test case logic and data (including navigationmaps, screen definitions, test verbs, and calls to external code) andgenerates and compiles executable code that performs the logic of thetest case. In some embodiments, code is generated in the C# programminglanguage and is targeted for a Microsoft .net framework.

Test management repository 130 may be used in some embodiments to storepreviously generated test that are deployed or otherwise readied foroperational use. In some embodiments, the execution module or modules132 are generated and compiled by code generator 110 and linked into aframework. In addition, test management repository 150 may manage testsession data 154. Session data 154 tracks which DUTs are in use, andwhich are available for testing.

FIG. 1B is a block diagram providing further details of a systemincorporating embodiments of the invention. In some embodiments, thesystem includes test development environment 102, repository service165, test execution service 170, test management service 175, webservice 180, and target service 160, which in some embodiments may becommunicably coupled via a network 185. Network 185 may be a corporateLAN, intranet, WAN or other network. Additionally, network 185 mayinclude the Internet. It should be noted that some or all of theservices shown in FIG. 1B may be included on a single system, in whichcase a network may not be required in order for such collocated servicesto communicate.

Repository service 165 is a repository manager that manages developmentrepository 12 and test management repository 150. In some embodiments,repository server 165 may include a database management service such asMicrosoft SQL server. Repository service 165 provides interfaces forother service to create, read, update and delete data in therepositories.

As noted above, test development environment 102 may be used to designand test a test application.

Web service 180 provides a web based interface to a browser to allowusers to control test execution for tests that have been deployed. Testmay be invoked immediately, or may be scheduled for future executionusing a browser in communication with web service 180.

Test management service 175 controls test scheduling. This may includetime of day, day of week scheduling, and may also include schedulingtest at matching devices and platforms become available. When a test isscheduled to run, test management service 175 sends a test executioncommand to test execution service 170.

Test execution service 170 receives commands to execute one or moretests. Test execution server selects an appropriate target service basedon test parameters, including searching for a matching test platform,and causes a test to be executed on a device under test 140 thatincludes a matching platform.

FIG. 1C is a block diagram showing the logical relationship of thevarious components described above in a system according to embodimentsof the invention.

FIG. 2 is a block diagram illustrating object management componentsaccording to embodiments of the invention. In some embodiments theobject management components include editor 202, layout object 210 anddata objects 220. data objects 220 include repository objects 121-131above, such as automated test cases 122, test verbs 123, navigation maps125, and screen definitions 124 (including screen component andcomponent type definition).

Editor 202 comprises any user interface component that may be used tovisualizes or change the properties a data object 220. Editor 202 mayinclude a view 204 and/or a model 206. Model 206 is a data object thatdefines the business logic of editor 202. View 204 is a visualrepresentation of editor 202 that is presented to the user.

Layout object 210 comprises a stored description of how the data object220 is shown in the given editor 202. Not every editor needs a layoutobject 210.

FIG. 3 illustrates an example main screen 300 of a test developmentenvironment 102 according to embodiments of the invention. In someembodiments, screen 300 includes one or more of an explorer pane 302, aproperties pane 306 and a detail pane 304. Explorer pane 302 in someembodiments provides a list of categories and objects that may exist ina repository, and provides an interface to select categories and itemsfor editing. In the example shown, explorer pane 302 includes userinterface elements for test sets, test cases, test verbs, navigationmaps, global variables, data sources, resource tables, custom code, anddeployment modules. Selection of a user interface element will typicallycause the explorer pane to show expanded or further details or a listingof particular data objects that may be selected for view, executionand/or editing. In the example shown, a Pocket PC 2003 platformdefinition have been selected. As a result of the selection, propertypane 306 has been displayed to show property values for variousproperties of the platform definition.

Properties pane 306 in some embodiments displays a list of propertiesassociated with a selected item. The properties may be selected, andvalues associated with the properties may be changed. Any manner ofediting a property value may be used, including direct text entry,selection from a drop-down box, selection from a check box, or otheruser interface editing device known in the art.

Detail pane 304 is typically used to provide a graphical representationof an interface element selected from explorer pane 302. Further detailson such graphical representations are illustrated below with referenceto FIGS. 5-6.

FIG. 4 illustrates an example flow diagram for test design. A typicaldesign flow 400 starts at 402 by providing templates for components usedin defining a screen. The example flow 400 for a test design is abottom-up design flow and is not the only flow possible. Top-down flowsand inside-out flows are possible and productive as well. An example ofa top-down flow would be to define a test case first followed bynavigation maps and test verbs. The purpose of templates is to automatethe process of creating screen components. The templates may providestandard property values and/or bitmap definitions for various userinterface elements of a device under test. In some embodiments, thetemplates may include buttons, boxes, menus, icons, tables, text fields,track bars, and keyboard elements.

Next, at 404, a component instance is created. The component instancemay be created from a template provided at 402 by dragging the templateover or near the relevant portion of a screen image as will be furtherdescribed below. In some embodiments components are automaticallyrecognized without user action when the screen is added to thenavigation map. In general, instances of components are related to thetemplate used to create the component instance. This is desirable,because a change in the template may be automatically propagated to allof the component instances that refer to the template. Templates maysignificantly reduce the user workload when creating components byautomatically recognizing the component on the screen, and byautomatically setting all the properties of the component.

At block 406, a screen is defined using components defined at block 404.In some embodiments, a screen is defined using one or more components,some or all of which must be present in order for the screen to berecognized and operate properly. A user interface for defining a screenaccording to embodiments of the invention is described below.

At bock 408, a navigation map is defined using one or more screens. Ingeneral, a navigation map comprises a set of one or more screens asdefined at block 406, together with commands and data that define thetransitions from one screen to another. A user interface for creatingand maintaining a navigation map is provided below.

At block 410, a test verb may be defined using test logic and thenavigation maps defined at block 408. Similarly, at block 412 a testcase may be defined using test logic the navigation maps defined atblock 408. The test logic for a test case may invoke a test verb. Aninterface screen for defining test logic and using navigation maps isdescribed below.

At block 414, a test set may be defines using one or more test cases.Similarly, at block 416 test sequence may be defined using one or moretest cases, one or more test sets, or a combination of test cases andtest sets. A test sequence may include an order of execution for thetest cases and test sets in the test sequence.

At block 418, a test session is defined. A test session defines theglobal variables, and other test parameters for a particular executionof a test sequence, test set, or test case.

FIGS. 5A-5C illustrate example navigation map panels and screen editorpanels of a test development environment according to embodiments of theinvention that may be used in the test design process illustrated inFIG. 4.

FIG. 5A illustrates example screen interfaces 502 and 504 for selectinga platform definition and device for a navigation map. In someembodiments, a platform definition is selected in the case that multiplepolymorphic versions of the navigation map have been defined. Screeninterface 502 provides an example platform definition selection screen.In some embodiments, a list of available platform types is provided in alist. The desired platform definition may be selected and used toprovide a platform definition context for the navigation map.

Screen interface 504 provides a device selection interface. Screen 504provides a list of available devices defined within the repository.Those devices having attributes that match the currently selectedplatform definition may be highlighted on one manner, while thosedevices whose attributes do not match the currently selected platformtype may be highlighted differently or not highlighted at all. Forexample, in some embodiments, devices having attributes that match thecurrently selected platform definition are displayed using green text,while devices that do not match the currently selected platform aredisplayed using red text.

FIG. 5B illustrates an example main navigation map screen 506 accordingto embodiments of the invention. In the example shown, a navigation maphas been selected from explorer pane 302, and detail pane 304 is updatedto display the selected navigation map 508. In the example, thenavigation map 508 includes data for navigating between five screens510.1-510.7. Screen 510.1 comprises a main screen on the DUT, screen510.2 comprises a tasks screen on the DUT, screen 510.3 comprises aclock screen, screen 510.4 comprises a main notes screen on the DUT,screen 510.5 comprises an owner information screen on the DUT, screen510.6 comprises a email screen, an screen 510.7 comprises an add notesscreen. Each of screens 510.2-510.6 is reachable from the main screen510.1, and each screen 510.2-510.6 can return to the main screen.However, screen 510.7 is reachable only through main notes screen 510.4.Connecting lines 512 illustrate the navigation between the screens. Insome embodiments, arrows indicate the direction in which navigation ispermitted. As shown in FIG. 5B, Navigation between screens is notlimited to screens that are directly connected. For example, to navigatefrom screen 510.1 to screen 510.7, the system automatically recognizesthat screen 510.6 may be used as an intermediate screen to get fromscreen 510.1 to 510.7.

Screens may be added and deleted from the navigation map. In someembodiments, recording buttons 514 may be used to add screens to anavigation map. The recording buttons may include a record button, pausebutton, and stop button. Upon pressing the record button, stimulusoriginating from a virtual device 519 is sent to the DUT and isrecorded. After the DUT has transitioned to new screens, as seen on thevirtual device 519, the user may press the add screen button 518. Afterthe add screen button 518 is press the screen is added to the navigationmap, displayed on navigation map 506, and may be saved. A connectingline 512 called a screen transition is placed on navigation map 502connecting the new screens to the originating screen. The connectingline 512 represents the stimulus (transition steps) that caused thescreen transition. The user may view or edit the transition step bydouble-clicking on the line, if for any reason the steps need to bechanged.

When not in record mode, selecting a screen 510 from navigation map 502causes the system to issue the appropriate commands to navigate to theselected screen on the DUT. In addition, the current screen may behighlighted on the navigation map 506 using any mechanism forhighlighting known in the art. For example, the screen border may bedisplayed in a different or brighter color then non-selected screens, orthe screen 510 may be made brighter or made to blink etc.

In some embodiments, a screen may be designated as the anchored screen.In this example, the anchored screen is designated by an anchor icon517. A screen anchor is a set of input steps that will cause the DUT togo to the anchored screen regardless of what screen the DUT is currentlyon. The system uses screen anchors when/if it cannot recognize thecurrent screen on the DUT. For example, most systems have a mechanismfor returning a screen to a home or initial screen, no matter whatscreen a DUT may currently be displaying. A screen anchor is useful inplacing the system in a known initial state when a test case begins. Inaddition, an anchor screen may be used to place the system at a knownscreen in the event that the system cannot locate a screen during ascreen navigation operation. This capability makes it possible tocontinue test execution even though a DUT failure has occurred. A visualindication is shown for screens which have screen identifier defined. Inthe example, screens with identifiers are shown with a green checkmarkicon 515.

As can be seen from the above, some embodiments implement a declarativescreen model for automated testing. In general, declarative modelsdescribe what something is like, rather than how to create it. Forexample, a declarative model describes the properties of the objects inthe model.

FIG. 5C illustrates a screen editor 520 according to embodiments of theinvention. Screen editor 520 may be entered upon selecting a screen fromnavigation map 506 when the test environment is not in record mode.Screen editor 520 includes a component explorer 528, screen bitmap pane522, and a screen component list 524. Screen bitmap pane 522 displays abitmap of the currently selected screen.

Component explorer 528 contains a list of templates for each type ofcomponent that may be used to define a screen of a DUT, and which may beautomatically recognized by the system.

Screen component list 524 displays a list of components defined for thescreen. The components may be recognized components or not recognizedcomponents. A recognized component is one that the system hassuccessfully detected as being present on the screen bitmap 522. In someembodiments, recognized components are highlighted on the screen bitmap522. For example, a recognized component such as a button may besurrounded by a highlighted box. In the example shown, owner button 526is among the components that have been recognized as present in screenbitmap 522. Not recognized components are components that have beendefined as possibly being present, but are not currently found on screenbitmap 522. In some embodiments, property panel 524 lists the recognizedcomponents and the unrecognized components defined for a particularscreen. Components in the list may be designated a screen identifiersthrough the use of a right-click menu. Components that have beendesignated as identifiers for the screen are shown by using bolded typefor component name 529. A screen identifier is a component or set ofcomponents that may be used to uniquely recognize a screen. The systemthen uses the screen identifiers to determine which screen a DUT iscurrently on, and may also use the screen identifiers to determine thatthe system has navigated to the correct screen.

In order to add a component to screen component list 524, a user selectsthe desired component type from component explorer pane 528. Arecognition rule editor is then invoked that allows a user to define howthe component will be recognized on a screen. Or, the user may use acomponent template that is listed under the component type. When acomponent template is used the component is automatically created, andtherefore the recognition rule editor is not invoked.

FIG. 5D illustrates a recognition rule editor 530 according toembodiments of the invention. In the example shown, a user has indicatedthat a button is to be recognized. The recognition rule editor 530includes a current screen bitmap 522, a recognition mode pane 532, and abitmap 534. Recognition mode 532 controls how the button will berecognized. In some embodiments, recognition may be position based, textbased, or icon based. In position based recognition, a particular bitpattern is expected at a particular position on the screen. The positionmay be defined using four corners, a border search, a line based search,or an absolute position. Additionally, recognized components may behighlighted on the screen. In some embodiments, recognized componentsare highlighted by placing a colored rectangle around the recognizedportion.

In text based recognition, text on a button label may used to recognizethe button. The user may select a bitmap for the text, upon which thesystem may perform optical character recognition in order to determinethe actual text contained in the bitmap. The user may then verify thecorrect text for the button.

In icon based recognition, a bitmap area for the button is selected fromscreen bitmap 522. In some embodiments, the user may define bits withinthe bitmap area as being significant to the button recognition, or as“don't care bits” in which the system will ignore the value for purposesof button recognition. For example, a square area may be selected thatcontains a circular button. Pixels in the four corners of the selectedarea that are outside of the circular button bitmap may be designated as“don't care” bits because they are not significant in detecting thepresence of the button. In addition, bits that may be set as part of abackground color may be designated as “don't care” bits in order toallow for the same button to be detected no matter what background auser has selected.

A screen recognition component may be designated as a templatecomponent. In this case, a template is defined for recognizing thecomponent. Once defined, the template may be applied to multiple screenswhere the same button may appear. Thus a user does not have to redefinea recognition rule for each screen a button may appear on. After acomponent template has been defined it appears under the parentcomponent type in the component explorer list 528.

FIG. 6A illustrates an example test design panel 600 of a testdevelopment environment according to embodiments of the invention. Ingeneral, the test design panel is used to create, edit, debug, and runtest cases and test verbs. The test design panel has three basic modesof operation. They are design, debug, and run modes. The design mode isused to create and edit test cases and verbs through recording on thevirtual device 519, or by drag and drop construction using test logicblocks. In the example shown, test panel 600 includes a test case flowchart 602 and a test logic block list 604. Test logic block list 604provides a list of the differing test symbols and operations that may beused to define a test case or test verb. Each symbol may comprise one ormore steps in the test logic. In some embodiments, the list includestest logic blocks to assign values to variables, invoke other testcases, catch exceptions, test conditions or values, invoke customwritten code, fill in variables or screen input areas with data from adata source, execute steps in the test case as part of a loop, executean expression, go to a screen on a platform, log text to a log file, orend the test case. Those of skill in the art will appreciate that othersymbols representing test logic may be used and are within the scope ofthe inventive subject matter

To create or edit a test case or test verb, a user selects the desiredtest symbol from symbol list 604 and drags the symbol to flow chart 602.A new symbol may be connected to a previously existing symbol eitherbased on the relative positions of the symbols, or a user may explicitlydrag a connecting line from one symbol to another. Connection points onthe symbols define the entry point for a test step and exit points forthe test step. In some embodiments, two exit connection points may beprovided. One connection point may be used to proceed to the next symbolif the current step successfully exits. A second connection point may beused to proceed to a differing symbol if the current step results in anerror condition. In addition to using drag and drop operations to createand edit test cases and test verbs, the virtual device 519 may be usedto add or insert test logic blocks into the test logic flow. DUTstimulus commands such as click on button or select menu item may berecorded into the test case or verb. When in design-record mode,components defined on the current screen are outlined to give the userfeedback as to the presence of the screen component. The use then canuse a right-click menu to record stimulus, read, or verify commandsassociated with the highlighted component. After command selection theDUT is stimulated, if the command is a stimulation command, and thecorresponding test logic block is inserted into the test case or testverb. In addition to recording commands associated with screencomponents, GoTo Screen and GoTo Platform commands may be recorded aswell. When a GoTo screen command is selected/recorded the systemautomatically navigates to the selected screen on the DUT by using theassociated navigation map. The corresponding test logic block isinserted into the test case or test verb. When a GoTo Platform commandis selected the system automatically switches the DUT context to the DUTassociated with the selected platform. Bubbles or clouds are used asbackground to show the test logic commands that are within the contextof GoTo Screen and GoTo Platform commands. Within a GoTo Screen contextbubble all the test logic blocks contained within are related to, or arein the context of, the selected screen. Within a GoTo Platform contextbubble all the test logic blocks contained within are related to, or arein the context of, the selected screen, including GoTo Screen blocks.

In some embodiments, icons within the symbols in test case flow chart602 indicate the type of symbol (loop, assignment etc.) and may also beselected to set break points at the symbol to be used for debuggingpurposes.

Further, in some embodiments, a variable window 606 may be displayed andused to examine the values of variables at various points in theexecution of a test case.

FIG. 7 illustrates methods 700 for creating and using screen componentsaccording to embodiments of the invention. The method begins in someembodiments at block 702, a system displays an interface providingcomponent templates for selection. As discussed above, a componenttemplate in some embodiments may include buttons, icons, menus, textfields, scroll areas, scroll bars etc. However, the inventive subjectmatter is not limited to any particular set of component templates. Insome embodiments, screen components may be displayed in addition to orinstead of component templates.

At block 704, the system displays a screen image obtained from a deviceunder test.

At block 706, the system receives a selection of a component template.In some embodiments, the selection comprises using a pointer device todrag a selected component template from a component list tosubstantially cover an area of the screen image where the component islocated. The area used by the component template to recognize thecomponent within the screen image may be indicated by a box having aboundary that may be adjusted if desired.

At block 708, the screen component instance is created from thecomponent template. In some embodiments, a recognition mode may be setfor the screen component instance at block 710. Various recognitionmodes are possible, including bitmap, text recognition, four cornersetc. as discussed above.

At block 710 a graphical rendition of the navigation map is displayed,reflecting the addition of the target screen to the navigation map.Additionally, an indication of the transition may be displayed. In someembodiments, the indication is a line connecting the source screen andthe target screen.

Blocks 706-710 may be repeated as desired to add multiple screencomponents for a screen image.

The actions at blocks 702-710 may be referred to as design-timeactivities. That is, they take place when an automated test procedure isbeing created or edited. After the design-time activities have takenplace, the run-time actions (blocks 712-718) using the previouslycreated screen components may take place.

At block 712 the system receives a screen image from a device undertest. The screen image may be received in the context of executing anautomated test procedure, such as a test case or a test verb, or thescreen image may be received as a result of a user editing a screenimage for a navigation map. The inventive subject matter is not limitedto any particular context for receiving the screen image.

At block 714 the system determines which components that have beenspecified as potentially existing on the screen, if any, are currentlyrecognized as being present on the screen. The system may user arecognition mode for each screen component to determine its presence onthe current screen image.

In some embodiments, at block 716 the system recognizes a screen basedon one or more of the recognized components. In this case, a screencomponent that has been defined as a label for the screen is recognizedas being present on the current screen image.

In some embodiments, at block 718 recognized screen components may behighlighted on a screen image representing a current screen of thedevice under test. Various forms of highlighting are possible and withinthe scope of the inventive subject matter. In particular embodiments, ahighlighted box is placed around the recognized component. Further, insome embodiments, recognized and unrecognized components may be listedon a display screen.

It should be noted that the component templates provided for selectionare typically the same regardless of the platform type or platformgroup. In some embodiments, the templates may be polymorphic asdescribed below. A screen component may be specialized for a particularplatform type or platform group, with the template serving as a base forthe modified screen component.

Additionally, in some embodiments, screen components may be associatedwith their respective base component template. In these embodiments,changes to the component template may be propagated to the screencomponents.

Multiple Device Environments

As discussed above, a system may include multiple target services 160,each of which may manage multiple devices under test 140. It should benoted that the number of devices under test 140 can grow quit large. Inaddition, many various types and versions of devices under test may becoupled to the system via target services 160, and that many differentsoftware environments may exist on the devices under test. As a result,the number of platform types, and platform groups, and platformdefinitions may be quite large and vary from system to system.

Additionally, an automated test procedure may need to deal with morethan one device under test during the design, debugging, and executionof the automated test procedure.

Thus in some embodiments, the system manages both pools of similardevices under test and groups of disparate devices under test. In someembodiments, platform definitions, platform types, and platform roles asdescribed above may be used to determine which of the many devices undertest that may be available within a system should be selected whendesigning, debugging, or executing an automated test procedure.

In some embodiments, a system selects a device under test based onwhether the candidate device is available and whether the candidatedevice attributes match the parameters defined by the platformdefinition, the platform group, the platform type, and/or any platformroles utilized by an automated test procedure.

A further aspect of a multi-device system of some embodiments includespolymorphism for various aspects of the system. In general, polymorphismrefers to ability to process objects differently depending on theirplatform type, platform group, platform definition, or role. In someembodiments, the system provides polymorphic navigation maps andpolymorphic test verbs. However, the embodiments are not limited toapplying polymorphic operation to any particular element of the system,and in alternative embodiments, polymorphism may be applied to otherelements. For example, some embodiments may provide polymorphiccomponent templates.

A polymorphic navigation map comprises a navigation map that may bereused across all of the platforms within a platform group. In general apolymorphic navigation map provides an abstraction of the presentationlayer for the platforms within a group. Thus the navigation map mayremain constant (and be reused) for platforms within a platform groupbecause the underlying behavior of the operating systems andapplications within a platform group does not change across devices in aplatform group.

A polymorphic test verb comprises a test verb that may be reused acrossplatform types. In general a polymorphic test verb provides anabstraction of the behavior of devices. For example, two devices mayimplement task list in very different ways, using different devicebehaviors to add tasks to the task list. However, a single polymorphictest verb labeled “CreateTask” may be called from an automated testprocedure. The interface to the test verb may remain constant, howeverdifferent version of the test verb may be implemented for variousplatform types. The particular instance of the test verb called may varydepending on the platform type for a current device under test. Theautomated test procedure need only call the polymorphic test verb, thesystem determines the particular instance of the test verb depending onthe platform context. Thus it may not be necessary to alter the testlogic of an automated test procedure when a new platform type is added,a designer may only need to supply an instance of the polymorphic testverb for the new platform type.

A further aspect of various embodiments includes managing test sessionsin which multiple test cases may need to access multiple devices. Thiscan occur because a single test case may access more than one deviceunder test, or different test cases may access different devices undertest. In some embodiments, the test cases may specify a platform role.During a test session, the platform role may be associated withparticular platform type, platform group, and/or platform definition.The system aggregates all of the roles within the potentially many testcases within a test session, and determines how many unique roles existfor the test session. Thus within a test session, each test case thatrefers to the same platform role will access the same device under test.This is desirable, because it allows a test designer to avoid having tospecify particular devices under test for each of what may be many testcases.

The systems and methods described above can include hardware, firmware,and/or software for performing the operations described herein.Furthermore, any of the components can include machine-readable mediaincluding instructions for causing a machine to perform the operationsdescribed herein. Machine-readable media includes any mechanism thatprovides (i.e., stores and/or transmits) information in a form readableby a machine (e.g. a computer). For example, tangible machine-readablemedia includes read only memory (ROM), random access memory (RAM),magnetic disk storage media, optical storage media, flash memorymachines, etc. Machine-readable media also includes any media suitablefor transmitting software over a network.

The illustrations of embodiments described herein are intended toprovide a general understanding of the structure of various embodiments,and they are not intended to serve as a complete description of all theelements and features of apparatus and systems that might make use ofthe structures described herein. The accompanying drawings that form apart hereof show by way of illustration, and not of limitation, specificembodiments in which the subject matter may be practiced.

Applications that may include the apparatus and systems of variousembodiments broadly include a variety of electronic and computersystems. The elements, materials, geometries, dimensions, and sequenceof operations can all be varied to suit particular packagingrequirements.

Embodiments illustrated are described in sufficient detail to enablethose skilled in the art to practice the teachings disclosed herein.Other embodiments may be utilized and derived therefrom, such thatstructural and logical substitutions and changes may be made withoutdeparting from the scope of this disclosure. This Detailed Description,therefore, is not to be taken in a limiting sense.

The Abstract is provided to comply with 37 C.F.R. § 1.72(b) to allow thereader to quickly ascertain the nature and gist of the technicaldisclosure. The Abstract is submitted with the understanding that itwill not be used to interpret or limit the scope or meaning of theclaims.

In the foregoing Detailed Description, various features are groupedtogether in a single embodiment for the purpose of streamlining thedisclosure. This method of disclosure is not to be interpreted asreflecting an intention that any embodiment have more features than areexpressly recited in a claim. Thus the following claims are herebyincorporated into the Detailed Description, with each claim standing onits own as a separate embodiment.

1. A method comprising: displaying an interface providing a plurality ofcomponent templates; displaying a screen image representing a screenimage of a device under test; receiving a selection of a componenttemplate of the plurality of component templates; and creating a screencomponent based on the selected component template; wherein theplurality of component templates is common to one or more disparatedevices under test.
 2. The method of claim 1, wherein the componenttemplates include one or more of button templates, menu templates, icontemplates, text field templates, box templates, or scroll areatemplates.
 3. The method of claim 1, wherein creating a screen componentincludes associating the screen component with one or more of a platformtype, a platform group or a platform definition.
 4. The method of claim1, further comprising associating a recognition mode with the screencomponent.
 5. The method of claim 4, wherein the recognition modeincludes a bitmap mode, a four corners mode, or a text recognition mode.6. A method comprising: receiving a screen image of a device under test;determining the presence of one or more screen components within thescreen image; and determining a recognized screen based on the presenceof one or more screen components.
 7. The method of claim 6, furthercomprising determining the one or more screen components in accordancewith one or more of a platform type, a platform group, or a platformdefinition.
 8. The method of claim 6, wherein determining the presenceof one or more screen components includes analyzing the screen image forthe one or more screen component in accordance with a recognition mode.9. The method of claim 9, wherein the recognition mode includes a bitmapmode, a four corners mode, or a text recognition mode.
 10. The method ofclaim 9, wherein the bitmap mode further includes a mask definitionwherein a portion of the bitmap is ignored during a comparison.
 11. Themethod of claim 6, further comprising highlighting screen componentsthat are recognized as present on the screen image.
 12. A systemcomprising: a test development environment; a component editor modulefor the test development environment to: display an interface providinga plurality of component templates; display a screen image representinga screen image of a device under test; receive a selection of acomponent template of the plurality of component templates; and create ascreen component based on the selected component template; wherein theplurality of component templates is common to one or more disparatedevices under test.